Disabling the OPC UA Complex Data extension

The OPC UA Complex Data extension is enabled by default.

Disabling the Complex Data plug-in may be useful e.g. for licensing reasons (when the product edition you have does not support the Complex Data plug-in, and you want to avoid the associated error), or for performance reasons (if you do not need the internal content of the value, for example if your code just needs to take the value read, and write it elsewhere).

Enabling or disabling the OPC UA Complex Data extension is done by settings the Enabled Property in the PluginSetup for the extension. You can locate the PluginSetup in the PluginSetups Property of the InstanceParameters of EasyUAClient. In order to find the proper PluginSetup, call the FindName Method on the PluginSetupCollection Class, giving it "UAComplexDataClient" string as an argument, or search the PluginSetups for a PluginSetup that has its UriString Property equal to EasyOpcUAUriStrings.ComplexDataClientPlugin.

// Shows how to disable and enable the OPC UA Complex Data plug-in.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
// OPC client and subscriber examples in C# on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-CSharp .
// Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
// a commercial license in order to use Online Forums, and we reply to every post.

using System;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;

namespace UADocExamples.ComplexData._PluginSetup
{
    class Enabled
    {
        public static void Main1()
        {
            // Define which server and node we will work with.
            UAEndpointDescriptor endpointDescriptor =
                "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
            // or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            // or "https://opcua.demo-this.com:51212/UA/SampleServer/"
            UANodeDescriptor nodeDescriptor =
                "nsu=http://test.org/UA/Data/ ;i=10239"; // [ObjectsFolder]/Data.Static.Scalar.StructureValue


            // We will explicitly disable the Complex Data plug-in, and read a node which returns complex data. We will 
            // receive an object of type UAExtensionObject, which contains the encoded data in its binary form. In this 
            // form, the data cannot be easily further processed by your application.
            //
            // Disabling the Complex Data plug-in may be useful e.g. for licensing reasons (when the product edition you 
            // have does not support the Complex Data plug-in, and you want to avoid the associated error), or for
            // performance reasons (if you do not need the internal content of the value, for example if your code just
            // needs to take the value read, and write it elsewhere).

            var client1 = new EasyUAClient();
            client1.InstanceParameters.PluginSetups.FindName("UAComplexDataClient").Enabled = false;

            object value1;
            try
            {
                value1 = client1.ReadValue(endpointDescriptor, nodeDescriptor);
            }
            catch (UAException uaException)
            {
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException().Message);
                return;
            }
            Console.WriteLine(value1);


            // Now we will read the same value, but with the Complex Data plug-in enabled. This time we will receive an
            // object of type UAGenericObject, which contains the data in the decoded form, accessible for further 
            // processing by your application.
            //
            // Note that it is not necessary to explicitly enable the Complex Data plug-in like this, because it is enabled
            // by default.

            var client2 = new EasyUAClient();
            client2.InstanceParameters.PluginSetups.FindName("UAComplexDataClient").Enabled = true;

            object value2 = client2.ReadValue(endpointDescriptor, nodeDescriptor);
            Console.WriteLine(value2);


            // Example output:
            //
            // Binary Byte[1373]; {nsu=http://test.org/UA/Data/ ;i=11437}
            // (ScalarValueDataType) structured

            // On the first line, the type and length of the encoded data is shown, and the node ID is the encoding ID.
            // On the 2nd line, the kind (structured) and the name of the complex data type (ScalarValueDataType) is shown.
        }
    }
}

' Shows how to disable and enable the OPC UA Complex Data plug-in.
'
' Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
' OPC client and subscriber examples in VB.NET on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-VBNET .
' Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
' a commercial license in order to use Online Forums, and we reply to every post.

Imports System
Imports OpcLabs.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.OperationModel

Namespace ComplexData._PluginSetup

    Friend Class Enabled

        Public Shared Sub Main1()

            ' Define which server we will work with.
            Dim endpointDescriptor As UAEndpointDescriptor =
                    "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            ' or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            ' or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            ' Define which node we will work with.
            Dim nodeDescriptor As UANodeDescriptor = _
                "nsu=http://test.org/UA/Data/ ;i=10239"  ' [ObjectsFolder]/Data.Static.Scalar.StructureValue


            ' We will explicitly disable the Complex Data plug-in, and read a node which returns complex data. We will 
            ' receive an object of type UAExtensionObject, which contains the encoded data in its binary form. In this 
            ' form, the data cannot be easily further processed by your application.
            '
            ' Disabling the Complex Data plug-in may be useful e.g. for licensing reasons (when the product edition you 
            ' have does not support the Complex Data plug-in, and you want to avoid the associated error), or for
            ' performance reasons (if you do not need the internal content of the value, for example if your code just
            ' needs to take the value read, and write it elsewhere).

            Dim client1 = New EasyUAClient
            client1.InstanceParameters.PluginSetups.FindName("UAComplexDataClient").Enabled = False

            Dim value1 As Object
            Try
                value1 = client1.ReadValue(endpointDescriptor, nodeDescriptor)
            Catch uaException As UAException
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException.Message)
                Exit Sub
            End Try
            Console.WriteLine(value1)


            ' Now we will read the same value, but with the Complex Data plug-in enabled. This time we will receive an
            ' object of type UAGenericObject, which contains the data in the decoded form, accessible for further 
            ' processing by your application.
            '
            ' Note that it is not necessary to explicitly enable the Complex Data plug-in like this, because it is enabled
            ' by default.

            Dim client2 = New EasyUAClient
            client2.InstanceParameters.PluginSetups.FindName("UAComplexDataClient").Enabled = True

            Dim value2 As Object
            Try
                value2 = client2.ReadValue(endpointDescriptor, nodeDescriptor)
            Catch uaException As UAException
                Console.WriteLine("*** Failure: {0}", uaException.GetBaseException.Message)
                Exit Sub
            End Try
            Console.WriteLine(value2)


            ' Example output:
            '
            ' Binary Byte[1373]; {nsu=http://test.org/UA/Data/ ;i=11437}
            ' (ScalarValueDataType) structured

            ' On the first line, the type and length of the encoded data is shown, and the node ID is the encoding ID.
            ' On the 2nd line, the kind (structured) and the name of the complex data type (ScalarValueDataType) is shown.
        End Sub
    End Class
End Namespace

COM

Object Pascal

// Shows how to disable and enable the OPC UA Complex Data plug-in.
//
// Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
// OPC client and subscriber examples in Object Pascal (Delphi) on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-OP .
// Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
// a commercial license in order to use Online Forums, and we reply to every post.

class procedure Enabled.Main;
var
  Client1, Client2: _EasyUAClient;
  EndpointDescriptor: string;
  NodeDescriptor: string;
  Value1, Value2: OleVariant;
begin
  // Define which server and node we will work with.
  EndpointDescriptor := 
    //'http://opcua.demo-this.com:51211/UA/SampleServer';
    //'https://opcua.demo-this.com:51212/UA/SampleServer/';
    'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer';
  NodeDescriptor := 'nsu=http://test.org/UA/Data/ ;i=10239';  // [ObjectsFolder]/Data.Static.Scalar.StructureValue

  // We will explicitly disable the Complex Data plug-in, and read a node which returns complex data. We will
  // receive an object of type UAExtensionObject, which contains the encoded data in its binary form. In this
  // form, the data cannot be easily further processed by your application.
  //
  // Disabling the Complex Data plug-in may be useful e.g. for licensing reasons (when the product edition you
  // have does not support the Complex Data plug-in, and you want to avoid the associated error), or for
  // performance reasons (if you do not need the internal content of the value, for example if your code just
  // needs to take the value read, and write it elsewhere).
  Client1 := CoEasyUAClient.Create;
  Client1.InstanceParameters.PluginSetups.FindName('UAComplexDataClient').Enabled := false;

  try
    Value1 := Client1.ReadValue(EndpointDescriptor, NodeDescriptor);
  except
    on E: EOleException do
    begin
      WriteLn(Format('*** Failure: %s', [E.GetBaseException.Message]));
      Exit;
    end;
  end;
  WriteLn(Value1);

  // Now we will read the same value, but with the Complex Data plug-in enabled. This time we will receive an
  // object of type UAGenericObject, which contains the data in the decoded form, accessible for further
  // processing by your application.
  //
  // Note that it is not necessary to explicitly enable the Complex Data plug-in like this, because it is enabled
  // by default.

  Client2 := CoEasyUAClient.Create;
  Client2.InstanceParameters.PluginSetups.FindName('UAComplexDataClient').Enabled := true;

  Value2 := Client2.ReadValue(EndpointDescriptor, NodeDescriptor);
  WriteLn(Value2);

  // Example output:
  //
  // Binary Byte[1373]; {nsu=http://test.org/UA/Data/ ;i=11437}
  // (ScalarValueDataType) structured

  // On the first line, the type and length of the encoded data is shown, and the node ID is the encoding ID.
  // On the 2nd line, the kind (structured) and the name of the complex data type (ScalarValueDataType) is shown.

end;

Python

Python (.NET)

# Shows how to disable and enable the OPC UA Complex Data plug-in.
#
# Find all latest examples here: https://opclabs.doc-that.com/files/onlinedocs/OPCLabs-OpcStudio/Latest/examples.html .
# OPC client and subscriber examples in Python on GitHub: https://github.com/OPCLabs/Examples-QuickOPC-Python .
# Missing some example? Ask us for it on our Online Forums, https://www.opclabs.com/forum/index ! You do not have to own
# a commercial license in order to use Online Forums, and we reply to every post.
# The QuickOPC package is needed. Install it using "pip install opclabs_quickopc".
import opclabs_quickopc

# Import .NET namespaces.
from OpcLabs.EasyOpc.UA import *
from OpcLabs.EasyOpc.UA.OperationModel import *


endpointDescriptor = UAEndpointDescriptor('opc.tcp://opcua.demo-this.com:51210/UA/SampleServer')
# or 'http://opcua.demo-this.com:51211/UA/SampleServer' (currently not supported)
# or 'https://opcua.demo-this.com:51212/UA/SampleServer/'

# [ObjectsFolder]/Data.Static.Scalar.StructureValue
nodeDescriptor = UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10239')


# We will explicitly disable the Complex Data plug-in, and read a node which returns complex data. We will
# receive an object of type UAExtensionObject, which contains the encoded data in its binary form. In this
# form, the data cannot be easily further processed by your application.
#
# Disabling the Complex Data plug-in may be useful e.g. for licensing reasons (when the product edition you
# have does not support the Complex Data plug-in, and you want to avoid the associated error), or for
# performance reasons (if you do not need the internal content of the value, for example if your code just
# needs to take the value read, and write it elsewhere).

client1 = EasyUAClient()
client1.InstanceParameters.PluginSetups.FindName('UAComplexDataClient').Enabled = False

try:
    value1 = IEasyUAClientExtension.ReadValue(client1, endpointDescriptor, nodeDescriptor)
except UAException as uaException:
    print('*** Failure: ' + uaException.GetBaseException().Message)
    exit()
print(value1)


# Now we will read the same value, but with the Complex Data plug-in enabled. This time we will receive an
# object of type UAGenericObject, which contains the data in the decoded form, accessible for further
# processing by your application.
#
# Note that it is not necessary to explicitly enable the Complex Data plug-in like this, because it is enabled
# by default.

client2 = EasyUAClient()
client2.InstanceParameters.PluginSetups.FindName('UAComplexDataClient').Enabled = True

try:
    value2 = IEasyUAClientExtension.ReadValue(client2, endpointDescriptor, nodeDescriptor)
except UAException as uaException:
    print('*** Failure: ' + uaException.GetBaseException().Message)
    exit()
print(value2)

print()
print('Finished.')

When the OPC UA Complex Data extension is disabled, the component

returns instances of UAExtensionObject Class when nodes with complex data are read or subscribed to,
expects instances of UAExtensionObject Class when nodes with complex data are written to,
does not allow you to obtain services related to OPC UA Complex Data (such as IEasyUAClientComplexData Interface from the instance of the EasyUAClient Class using the GetService Method.

When the OPC UA Complex Data extension is enabled (the default) but the current license does not allow the OPC UA Complex Data feature, reads, subscriptions and writes, or attempts to obtain services related to OPC UA Complex Data, will return an error.

Enabling or disabling the extension only has effect when done before you attempt first OPC operation or GetService Method call on the object instance.

Reference

PluginSetups Property

PluginSetup Class

Enabled Property

UriString Property

PluginSetupCollection Class

FindName Method

EasyUAClient Class

EasyUAUriStrings Class

GetService Method

IEasyUAClientComplexData Interface